main.spec.js ➔ ... ➔ it(ꞌItems is correctꞌ) - Code Metrics - Inspection of "Scrutinizer exclude test folder" - junebug12851/pokered-mon-database - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 1ddf8c...065ccb )

by June

created 2019-03-27 17:05 UTC

main.spec.js ➔ ... ➔ it(ꞌItems is correctꞌ) A

↳ Parent: Project

Complexity

Conditions	4
Paths	5

Size

Total Lines	35
Code Lines	23

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
cc	4
eloc	23
c	2
b	0
f	0
nc	5
nop	0
dl	0
loc	35
rs	9.328

const itemsRaw = require("../src/data/items.json");
const movesRaw = require("../src/data/moves.json");
const pokemonRaw = require("../src/data/pokemon.json");
const typesRaw = require("../src/data/types.json");

const PokemonDB = (require("../src/index")).PokemonDB;

const _ = require("lodash");

describe("Tests", function() {

    beforeEach(function() {
        this.db = new PokemonDB();
    });

    it("Items is correct", function() {

        for(let i = 0; i < itemsRaw.length; i++) {
            const item = itemsRaw[i];

            expect(this.db.items[item.ind]).toEqual(jasmine.any(Object));

            const dbItem = this.db.items[item.ind];

            expect(this.db.items[_.snakeCase(item.name)]).toEqual(dbItem);
            expect(this.db.items[item.name]).toEqual(dbItem);

            if(item.tm !== undefined) {
                expect(this.db.items["tm" + item.tm]).toEqual(dbItem);
                expect(dbItem.tm).toEqual(jasmine.any(Object));
                expect(dbItem.tm._tm).toEqual(dbItem._tm);
                expect(typeof dbItem._tm).toEqual("number");
            }
            else {
                expect(dbItem.tm).not.toBeDefined();
                expect(dbItem._tm).not.toBeDefined();
            }

            if(item.hm !== undefined) {
                expect(this.db.items["hm" + item.hm]).toEqual(dbItem);
                expect(dbItem.hm).toEqual(jasmine.any(Object));
                expect(dbItem.hm._hm).toEqual(dbItem._hm);
                expect(typeof dbItem._hm).toEqual("number");
            }
            else {
                expect(dbItem.hm).not.toBeDefined();
                expect(dbItem._hm).not.toBeDefined();
            }
        }
    });

    it("Moves is correct", function() {
        for(let i = 0; i < movesRaw.length; i++) {
            const move = movesRaw[i];

            expect(this.db.moves[move.ind]).toEqual(jasmine.any(Object));

            const dbMove = this.db.moves[move.ind];

            expect(this.db.moves[_.snakeCase(move.name)]).toEqual(dbMove);
            expect(this.db.moves[move.name]).toEqual(dbMove);

            if(move.tm !== undefined) {
                expect(this.db.moves["tm" + move.tm]).toEqual(dbMove);
                expect(dbMove.tm).toEqual(jasmine.any(Object));
                expect(dbMove.tm._tm).toEqual(dbMove._tm);
                expect(typeof dbMove._tm).toEqual("number");
            }
            else {
                expect(dbMove.tm).not.toBeDefined();
                expect(dbMove._tm).not.toBeDefined();
            }

            if(move.hm !== undefined) {
                expect(this.db.moves["hm" + move.hm]).toEqual(dbMove);
                expect(dbMove.hm).toEqual(jasmine.any(Object));
                expect(dbMove.hm._hm).toEqual(dbMove._hm);
                expect(typeof dbMove._hm).toEqual("number");
            }
            else {
                expect(dbMove.hm).not.toBeDefined();
                expect(dbMove._hm).not.toBeDefined();
            }

            if(move.type !== undefined) {
                expect(dbMove.type).toEqual(jasmine.any(Object));
                expect(dbMove.type.name).toEqual(dbMove._type);
                expect(typeof dbMove._type).toEqual("string");
            }
            else {
                expect(dbMove.type).not.toBeDefined();
                expect(dbMove._type).not.toBeDefined();
            }
        }
    });

    it("Types is correct", function() {

        for(let i = 0; i < typesRaw.length; i++) {
            const type = typesRaw[i];

            expect(this.db.types[type.ind]).toEqual(jasmine.any(Object));

            const dbType = this.db.types[type.ind];

            expect(this.db.types[_.snakeCase(type.name)]).toEqual(dbType);
            expect(this.db.types[type.name]).toEqual(dbType);
        }
    });

    it("Pokemon is correct", function() {
        for(let i = 0; i < pokemonRaw.length; i++) {
            const pokemon = pokemonRaw[i];

            expect(this.db.pokemon[pokemon.ind]).toEqual(jasmine.any(Object));

            const dbMon = this.db.pokemon[pokemon.ind];

            expect(this.db.pokemon[_.snakeCase(pokemon.name)]).toEqual(dbMon);
            expect(this.db.pokemon[pokemon.name]).toEqual(dbMon);

            if(pokemon.type1 !== undefined) {
                expect(dbMon.type1).toEqual(jasmine.any(Object));
                expect(dbMon.type1.name).toEqual(dbMon._type1);
                expect(typeof dbMon._type1).toEqual("string");
            }
            else {
                expect(dbMon.type1).not.toBeDefined();
                expect(dbMon._type1).not.toBeDefined();
            }

            if(pokemon.type2 !== undefined) {
                expect(dbMon.type2).toEqual(jasmine.any(Object));
                expect(dbMon.type2.name).toEqual(dbMon._type2);
                expect(typeof dbMon._type2).toEqual("string");
            }
            else {
                expect(dbMon.type2).not.toBeDefined();
                expect(dbMon._type2).not.toBeDefined();
            }

            if(pokemon.evolution !== undefined && !Array.isArray(pokemon.evolution)) {
                expect(dbMon.evolution.toName).toEqual(jasmine.any(Object));
                expect(dbMon.evolution.toName.name).toEqual(dbMon.evolution._toName);
                expect(typeof dbMon.evolution._toName).toEqual("string");

                if(pokemon.evolution.level !== undefined) {
                    expect(dbMon.evolution.item).not.toBeDefined();
                    expect(dbMon.evolution._item).not.toBeDefined();
                    expect(dbMon.evolution.trade).not.toBeDefined();
                }
                else if(pokemon.evolution.trade !== undefined) {
                    expect(dbMon.evolution.item).not.toBeDefined();
                    expect(dbMon.evolution._item).not.toBeDefined();
                    expect(dbMon.evolution.level).not.toBeDefined();
                }
                else if(pokemon.evolution.item !== undefined) {
                    expect(dbMon.evolution.trade).not.toBeDefined();
                    expect(dbMon.evolution.level).not.toBeDefined();

                    expect(dbMon.evolution.item).toEqual(jasmine.any(Object));
                    expect(dbMon.evolution.item.name).toEqual(dbMon.evolution._item);
                    expect(typeof dbMon.evolution._item).toEqual("string");
                }
                else if(pokemon.evolution.item === undefined) {
                    expect(dbMon.evolution.item).not.toBeDefined();
                    expect(dbMon.evolution._item).not.toBeDefined();
                }
            }
            else if(pokemon.evolution !== undefined && Array.isArray(pokemon.evolution)) {
                for(let j = 0; j < pokemon.evolution.length; j++) {
                    expect(dbMon.evolution[j].toName).toEqual(jasmine.any(Object));
                    expect(dbMon.evolution[j].toName.name).toEqual(dbMon.evolution[j]._toName);
                    expect(typeof dbMon.evolution[j]._toName).toEqual("string");

                    if(pokemon.evolution[j].level !== undefined) {
                        expect(dbMon.evolution[j].item).not.toBeDefined();
                        expect(dbMon.evolution[j]._item).not.toBeDefined();
                        expect(dbMon.evolution[j].trade).not.toBeDefined();
                    }
                    else if(pokemon.evolution[j].trade !== undefined) {
                        expect(dbMon.evolution[j].item).not.toBeDefined();
                        expect(dbMon.evolution[j]._item).not.toBeDefined();
                        expect(dbMon.evolution[j].level).not.toBeDefined();
                    }
                    else if(pokemon.evolution[j].item !== undefined) {
                        expect(dbMon.evolution[j].trade).not.toBeDefined();
                        expect(dbMon.evolution[j].level).not.toBeDefined();

                        expect(dbMon.evolution[j].item).toEqual(jasmine.any(Object));
                        expect(dbMon.evolution[j].item.name).toEqual(dbMon.evolution[j]._item);
                        expect(typeof dbMon.evolution[j]._item).toEqual("string");
                    }
                    else if(pokemon.evolution[j].item === undefined) {
                        expect(dbMon.evolution[j].item).not.toBeDefined();
                        expect(dbMon.evolution[j]._item).not.toBeDefined();
                    }
                }
            }

            if(pokemon.moves !== undefined) {
                expect(Array.isArray(dbMon.moves)).toEqual(true);
                for(let j = 0; j < pokemon.moves.length; j++) {
                    expect(dbMon.moves[j].level).toBeDefined();
                    expect(dbMon.moves[j].move).toEqual(jasmine.any(Object));
                    expect(dbMon.moves[j].move.name).toEqual(dbMon.moves[j]._move);
                    expect(typeof dbMon.moves[j]._move).toEqual("string");
                }
            }

            if(pokemon.initial !== undefined) {
                expect(Array.isArray(dbMon.initial)).toEqual(true);
                expect(Array.isArray(dbMon._initial)).toEqual(true);
                for(let j = 0; j < pokemon.initial.length; j++) {
                    expect(dbMon.initial[j]).toEqual(jasmine.any(Object));
                    expect(dbMon.initial[j].name).toEqual(dbMon._initial[j]);
                    expect(typeof dbMon._initial[j]).toEqual("string");
                }
            }
            else {
                expect(dbMon.initial).not.toBeDefined();
                expect(dbMon._initial).not.toBeDefined();
            }

            if(pokemon.tmHm !== undefined) {
                expect(Array.isArray(dbMon.tmHm)).toEqual(true);
                expect(Array.isArray(dbMon._tmHm)).toEqual(true);
                for(let j = 0; j < pokemon.tmHm.length; j++) {
                    expect(dbMon.tmHm[j]).toEqual(jasmine.any(Object));
                    expect(dbMon.tmHm[j]._tm).toEqual(dbMon._tmHm[j]);
                    expect(typeof dbMon._tmHm[j]).toEqual("number");
                }
            }
            else {
                expect(dbMon.tmHm).not.toBeDefined();
                expect(dbMon._tmHm).not.toBeDefined();
            }
        }
    });
});


1			const itemsRaw = require("../src/data/items.json");
2			const movesRaw = require("../src/data/moves.json");
3			const pokemonRaw = require("../src/data/pokemon.json");
4			const typesRaw = require("../src/data/types.json");
5
6			const PokemonDB = (require("../src/index")).PokemonDB;
7
8			const _ = require("lodash");
9
10			describe("Tests", function() {
11
12			beforeEach(function() {
13			this.db = new PokemonDB();
14			});
15
16			it("Items is correct", function() {
17
18			for(let i = 0; i < itemsRaw.length; i++) {
19			const item = itemsRaw[i];
20
21			expect(this.db.items[item.ind]).toEqual(jasmine.any(Object));
22
23			const dbItem = this.db.items[item.ind];
24
25			expect(this.db.items[_.snakeCase(item.name)]).toEqual(dbItem);
26			expect(this.db.items[item.name]).toEqual(dbItem);
27
28			if(item.tm !== undefined) {
29			expect(this.db.items["tm" + item.tm]).toEqual(dbItem);
30			expect(dbItem.tm).toEqual(jasmine.any(Object));
31			expect(dbItem.tm._tm).toEqual(dbItem._tm);
32			expect(typeof dbItem._tm).toEqual("number");
33			}
34			else {
35			expect(dbItem.tm).not.toBeDefined();
36			expect(dbItem._tm).not.toBeDefined();
37			}
38
39			if(item.hm !== undefined) {
40			expect(this.db.items["hm" + item.hm]).toEqual(dbItem);
41			expect(dbItem.hm).toEqual(jasmine.any(Object));
42			expect(dbItem.hm._hm).toEqual(dbItem._hm);
43			expect(typeof dbItem._hm).toEqual("number");
44			}
45			else {
46			expect(dbItem.hm).not.toBeDefined();
47			expect(dbItem._hm).not.toBeDefined();
48			}
49			}
50			});
51
52			it("Moves is correct", function() {
53			for(let i = 0; i < movesRaw.length; i++) {
54			const move = movesRaw[i];
55
56			expect(this.db.moves[move.ind]).toEqual(jasmine.any(Object));
57
58			const dbMove = this.db.moves[move.ind];
59
60			expect(this.db.moves[_.snakeCase(move.name)]).toEqual(dbMove);
61			expect(this.db.moves[move.name]).toEqual(dbMove);
62
63			if(move.tm !== undefined) {
64			expect(this.db.moves["tm" + move.tm]).toEqual(dbMove);
65			expect(dbMove.tm).toEqual(jasmine.any(Object));
66			expect(dbMove.tm._tm).toEqual(dbMove._tm);
67			expect(typeof dbMove._tm).toEqual("number");
68			}
69			else {
70			expect(dbMove.tm).not.toBeDefined();
71			expect(dbMove._tm).not.toBeDefined();
72			}
73
74			if(move.hm !== undefined) {
75			expect(this.db.moves["hm" + move.hm]).toEqual(dbMove);
76			expect(dbMove.hm).toEqual(jasmine.any(Object));
77			expect(dbMove.hm._hm).toEqual(dbMove._hm);
78			expect(typeof dbMove._hm).toEqual("number");
79			}
80			else {
81			expect(dbMove.hm).not.toBeDefined();
82			expect(dbMove._hm).not.toBeDefined();
83			}
84
85			if(move.type !== undefined) {
86			expect(dbMove.type).toEqual(jasmine.any(Object));
87			expect(dbMove.type.name).toEqual(dbMove._type);
88			expect(typeof dbMove._type).toEqual("string");
89			}
90			else {
91			expect(dbMove.type).not.toBeDefined();
92			expect(dbMove._type).not.toBeDefined();
93			}
94			}
95			});
96
97			it("Types is correct", function() {
98
99			for(let i = 0; i < typesRaw.length; i++) {
100			const type = typesRaw[i];
101
102			expect(this.db.types[type.ind]).toEqual(jasmine.any(Object));
103
104			const dbType = this.db.types[type.ind];
105
106			expect(this.db.types[_.snakeCase(type.name)]).toEqual(dbType);
107			expect(this.db.types[type.name]).toEqual(dbType);
108			}
109			});
110
111			it("Pokemon is correct", function() {
112			for(let i = 0; i < pokemonRaw.length; i++) {
113			const pokemon = pokemonRaw[i];
114
115			expect(this.db.pokemon[pokemon.ind]).toEqual(jasmine.any(Object));
116
117			const dbMon = this.db.pokemon[pokemon.ind];
118
119			expect(this.db.pokemon[_.snakeCase(pokemon.name)]).toEqual(dbMon);
120			expect(this.db.pokemon[pokemon.name]).toEqual(dbMon);
121
122			if(pokemon.type1 !== undefined) {
123			expect(dbMon.type1).toEqual(jasmine.any(Object));
124			expect(dbMon.type1.name).toEqual(dbMon._type1);
125			expect(typeof dbMon._type1).toEqual("string");
126			}
127			else {
128			expect(dbMon.type1).not.toBeDefined();
129			expect(dbMon._type1).not.toBeDefined();
130			}
131
132			if(pokemon.type2 !== undefined) {
133			expect(dbMon.type2).toEqual(jasmine.any(Object));
134			expect(dbMon.type2.name).toEqual(dbMon._type2);
135			expect(typeof dbMon._type2).toEqual("string");
136			}
137			else {
138			expect(dbMon.type2).not.toBeDefined();
139			expect(dbMon._type2).not.toBeDefined();
140			}
141
142			if(pokemon.evolution !== undefined && !Array.isArray(pokemon.evolution)) {
143			expect(dbMon.evolution.toName).toEqual(jasmine.any(Object));
144			expect(dbMon.evolution.toName.name).toEqual(dbMon.evolution._toName);
145			expect(typeof dbMon.evolution._toName).toEqual("string");
146
147			if(pokemon.evolution.level !== undefined) {
148			expect(dbMon.evolution.item).not.toBeDefined();
149			expect(dbMon.evolution._item).not.toBeDefined();
150			expect(dbMon.evolution.trade).not.toBeDefined();
151			}
152			else if(pokemon.evolution.trade !== undefined) {
153			expect(dbMon.evolution.item).not.toBeDefined();
154			expect(dbMon.evolution._item).not.toBeDefined();
155			expect(dbMon.evolution.level).not.toBeDefined();
156			}
157			else if(pokemon.evolution.item !== undefined) {
158			expect(dbMon.evolution.trade).not.toBeDefined();
159			expect(dbMon.evolution.level).not.toBeDefined();
160
161			expect(dbMon.evolution.item).toEqual(jasmine.any(Object));
162			expect(dbMon.evolution.item.name).toEqual(dbMon.evolution._item);
163			expect(typeof dbMon.evolution._item).toEqual("string");
164			}
165			else if(pokemon.evolution.item === undefined) {
166			expect(dbMon.evolution.item).not.toBeDefined();
167			expect(dbMon.evolution._item).not.toBeDefined();
168			}
169			}
170			else if(pokemon.evolution !== undefined && Array.isArray(pokemon.evolution)) {
171			for(let j = 0; j < pokemon.evolution.length; j++) {
172			expect(dbMon.evolution[j].toName).toEqual(jasmine.any(Object));
173			expect(dbMon.evolution[j].toName.name).toEqual(dbMon.evolution[j]._toName);
174			expect(typeof dbMon.evolution[j]._toName).toEqual("string");
175
176			if(pokemon.evolution[j].level !== undefined) {
177			expect(dbMon.evolution[j].item).not.toBeDefined();
178			expect(dbMon.evolution[j]._item).not.toBeDefined();
179			expect(dbMon.evolution[j].trade).not.toBeDefined();
180			}
181			else if(pokemon.evolution[j].trade !== undefined) {
182			expect(dbMon.evolution[j].item).not.toBeDefined();
183			expect(dbMon.evolution[j]._item).not.toBeDefined();
184			expect(dbMon.evolution[j].level).not.toBeDefined();
185			}
186			else if(pokemon.evolution[j].item !== undefined) {
187			expect(dbMon.evolution[j].trade).not.toBeDefined();
188			expect(dbMon.evolution[j].level).not.toBeDefined();
189
190			expect(dbMon.evolution[j].item).toEqual(jasmine.any(Object));
191			expect(dbMon.evolution[j].item.name).toEqual(dbMon.evolution[j]._item);
192			expect(typeof dbMon.evolution[j]._item).toEqual("string");
193			}
194			else if(pokemon.evolution[j].item === undefined) {
195			expect(dbMon.evolution[j].item).not.toBeDefined();
196			expect(dbMon.evolution[j]._item).not.toBeDefined();
197			}
198			}
199			}
200
201			if(pokemon.moves !== undefined) {
202			expect(Array.isArray(dbMon.moves)).toEqual(true);
203			for(let j = 0; j < pokemon.moves.length; j++) {
204			expect(dbMon.moves[j].level).toBeDefined();
205			expect(dbMon.moves[j].move).toEqual(jasmine.any(Object));
206			expect(dbMon.moves[j].move.name).toEqual(dbMon.moves[j]._move);
207			expect(typeof dbMon.moves[j]._move).toEqual("string");
208			}
209			}
210
211			if(pokemon.initial !== undefined) {
212			expect(Array.isArray(dbMon.initial)).toEqual(true);
213			expect(Array.isArray(dbMon._initial)).toEqual(true);
214			for(let j = 0; j < pokemon.initial.length; j++) {
215			expect(dbMon.initial[j]).toEqual(jasmine.any(Object));
216			expect(dbMon.initial[j].name).toEqual(dbMon._initial[j]);
217			expect(typeof dbMon._initial[j]).toEqual("string");
218			}
219			}
220			else {
221			expect(dbMon.initial).not.toBeDefined();
222			expect(dbMon._initial).not.toBeDefined();
223			}
224
225			if(pokemon.tmHm !== undefined) {
226			expect(Array.isArray(dbMon.tmHm)).toEqual(true);
227			expect(Array.isArray(dbMon._tmHm)).toEqual(true);
228			for(let j = 0; j < pokemon.tmHm.length; j++) {
229			expect(dbMon.tmHm[j]).toEqual(jasmine.any(Object));
230			expect(dbMon.tmHm[j]._tm).toEqual(dbMon._tmHm[j]);
231			expect(typeof dbMon._tmHm[j]).toEqual("number");
232			}
233			}
234			else {
235			expect(dbMon.tmHm).not.toBeDefined();
236			expect(dbMon._tmHm).not.toBeDefined();
237			}
238			}
239			});
240			});
241

junebug12851 / pokered-mon-database

Push — master ( 1ddf8c...065ccb )

main.spec.js ➔ ... ➔ it(ꞌItems is correctꞌ) A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like